home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / kernel / sync / sync.h < prev    next >
Encoding:
C/C++ Source or Header  |  1992-12-19  |  24.0 KB  |  937 lines
  1. /*
  2.  * sync.h --
  3.  *
  4.  *     Definitions of routines for the synchronization module.
  5.  *     The synchronization module provides locks and condition
  6.  *     variables to other modules, plus a low level binary semaphore 
  7.  *    needed to synchronize with interrupt handlers.
  8.  *
  9.  *    The behavior of the sync module can be modified using compiler 
  10.  *    variables. These variables will change the structure of locks and
  11.  *    how the locks are used. In general it is not a good idea to link
  12.  *    modules that have been compiled with different versions of locks.
  13.  *    
  14.  *        <default> -     semaphores and locks have fields that contain a
  15.  *              character string name, the pc where the lock was
  16.  *             last locked, and a pointer to the pcb of the last
  17.  *             lock holder. The locking operation is slower because
  18.  *             these fields must be updated.
  19.  *
  20.  *        CLEAN_LOCK - locks do not contain any extra fields. This version
  21.  *                 of locks is intended for benchmarking the kernel.
  22.  *    
  23.  *        LOCKREG    - locks are registered so that the information stored
  24.  *             in them can be retrieved. In addition to the fields
  25.  *             in the default version of locks, a count of hits
  26.  *             and misses on each lock is kept. Lock registration
  27.  *             must be done when the lock is created and destroyed.
  28.  *             The locking operation is slower due to the hit/miss
  29.  *             counters.  A count is kept for each spin lock that
  30.  *             records the number of times a processor spun waiting
  31.  *             for the lock.
  32.  *
  33.  *        LOCKDEP    - Each lock keeps a list of locks that were held when
  34.  *             it was locked in addition to the information kept
  35.  *             in the LOCKREG version. Locks compiled with LOCKDEP
  36.  *                 will get very large. This information can be used to 
  37.  *             construct a graph of the locking behavior of the
  38.  *             kernel. Locking and unlocking is slowed down due
  39.  *             to the necessity of recording previously held lock.
  40.  *
  41.  *
  42.  * Copyright 1986 Regents of the University of California
  43.  * All rights reserved.
  44.  *
  45.  * $Header: /cdrom/src/kernel/Cvsroot/kernel/sync/sync.h,v 9.12 91/08/15 17:56:24 jhh Exp $ SPRITE (Berkeley)
  46.  */
  47.  
  48. #ifndef _SYNC
  49. #define _SYNC
  50.  
  51. #include <sprite.h>
  52. #include <list.h>
  53.  
  54. #ifdef KERNEL
  55. #include <syncTypes.h>
  56. #include <mach.h>
  57. #include <proc.h>
  58. #else
  59. #include <kernel/syncTypes.h>
  60. #include <kernel/mach.h>
  61. #include <kernel/proc.h>
  62. #endif /* KERNEL */
  63.  
  64. /*
  65.  * These include files are needed by the SysV sema support.
  66.  */
  67. #include <sys/types.h>
  68. #include <sys/ipc.h>
  69. #include <sys/sem.h>
  70.  
  71. /*
  72.  * Exported procedures and variables of the sync module.
  73.  */
  74.     
  75. extern Sync_Instrument     sync_Instrument[MACH_MAX_NUM_PROCESSORS];
  76. extern Sync_Instrument    *sync_InstrumentPtr[MACH_MAX_NUM_PROCESSORS];
  77. extern int sync_BusyWaits;
  78.  
  79. extern void Sync_Init _ARGS_((void));
  80. extern ReturnStatus Sync_GetLock _ARGS_((Sync_Lock *lockPtr));
  81. extern ReturnStatus Sync_Unlock _ARGS_((Sync_Lock *lockPtr));
  82. extern ReturnStatus Sync_SlowLock _ARGS_((register Sync_Lock *lockPtr));
  83. extern Boolean Sync_SlowWait _ARGS_((Sync_Condition *conditionPtr, 
  84.             Sync_Lock *lockPtr, Boolean wakeIfSignal));
  85. extern ReturnStatus Sync_SlowBroadcast _ARGS_((unsigned int event, 
  86.             int *waitFlagPtr));
  87.  
  88. extern Boolean Sync_SlowMasterWait _ARGS_((unsigned int event,
  89.             Sync_Semaphore *mutexPtr, Boolean wakeIfSignal));
  90. extern void Sync_UnlockAndSwitch _ARGS_((Sync_Lock *lockPtr, Proc_State state));
  91. extern void Sync_WakeWaitingProcess _ARGS_((register Proc_ControlBlock *procPtr));
  92. extern void Sync_WakeupProcess _ARGS_((Timer_Ticks time, ClientData procAddress));
  93.  
  94. extern void Sync_GetWaitToken _ARGS_((Proc_PID *pidPtr, int *tokenPtr));
  95. extern void Sync_SetWaitToken _ARGS_((Proc_ControlBlock *procPtr, int waitToken));
  96.  
  97. extern Boolean Sync_WaitTime _ARGS_((Time time));
  98. extern Boolean Sync_WaitTimeInTicks _ARGS_((Timer_Ticks time));
  99. extern Boolean Sync_WaitTimeInterval _ARGS_((unsigned int interval));
  100.  
  101. extern Boolean Sync_ProcWait _ARGS_((Sync_Lock *lockPtr, Boolean wakeIfSignal));
  102. extern void Sync_ProcWakeup _ARGS_((Proc_PID pid, int token));
  103.  
  104. extern ReturnStatus Sync_RemoteNotify _ARGS_((Sync_RemoteWaiter *waitPtr));
  105. extern ReturnStatus Sync_RemoteNotifyStub _ARGS_((ClientData srvToken, 
  106.             int clientID, int command, Rpc_Storage *storagePtr));
  107.  
  108. extern ReturnStatus Sync_SlowLockStub _ARGS_((Sync_UserLock *lockPtr));
  109. extern ReturnStatus Sync_SlowWaitStub _ARGS_((unsigned int event, 
  110.             Sync_UserLock *lockPtr, Boolean wakeIfSignal));
  111. extern ReturnStatus Sync_SlowBroadcastStub _ARGS_((unsigned int event,
  112.                 int *waitFlagPtr));
  113.  
  114. extern void Sync_PrintStat _ARGS_((void));
  115.  
  116. extern void Sync_LockStatInit _ARGS_((void));
  117. extern void SyncAddPriorInt _ARGS_((int type, int *priorCountPtr, 
  118.             int *priorTypes, Address lockPtr, 
  119.             Proc_ControlBlock *pcbPtr));
  120.  
  121. extern void SyncDeleteCurrentInt _ARGS_((Address lockPtr, 
  122.                 Proc_ControlBlock *pcbPtr));
  123. extern void SyncMergePriorInt _ARGS_((int priorCount, int *priorTypes, 
  124.                 Sync_RegElement *regPtr));
  125. extern void Sync_RegisterInt _ARGS_((Address lock));
  126. extern void Sync_CheckoutInt _ARGS_((Address lock));
  127.  
  128. extern ReturnStatus Sync_SemgetStub _ARGS_((long key, int nsems, int semflg, 
  129.                     int *retValOut));
  130. extern ReturnStatus Sync_SemopStub _ARGS_((int semid, struct sembuf *sopsIn, 
  131.                     int nsops, int retValOut));
  132.  
  133. extern ReturnStatus Sync_SemctlStub _ARGS_((int semid, int semnum, int cmd, 
  134.                     union semun arg, int *retValOut));
  135. extern ReturnStatus Sync_SemStruct _ARGS_((int id, int *perm, 
  136.                        Sync_SysVSem **retPtr));
  137.  
  138. extern ReturnStatus Sync_Sleep _ARGS_((Time time));
  139. extern void Sync_SemInit _ARGS_((void));
  140.  
  141. extern ReturnStatus Sync_GetLockStats _ARGS_((int size, Address argPtr));
  142. extern ReturnStatus Sync_ResetLockStats _ARGS_((void));
  143.  
  144. extern void Sync_RemoveWaiter _ARGS_((Proc_ControlBlock *procPtr));
  145.  
  146. extern Sync_RegElement  *regQueuePtr;
  147.  
  148.  
  149.  
  150. /*
  151.  *----------------------------------------------------------------------------
  152.  *
  153.  * MASTER_LOCK --
  154.  *
  155.  *    Enter a critical section guarded by a binary semaphore.
  156.  *    This is for use in a multiprocessor environment
  157.  *    within the synchronization module, and in other
  158.  *    modules that interact with interrupt-time routines.
  159.  *    (All other synchronization should be done with Monitors.)
  160.  *    
  161.  *    Interrupts are disabled on the local processor to prevent
  162.  *    a preemptive context switch.  The semaphore is checked
  163.  *    with a Mach_TestAndSet atomic operation in a busy wait
  164.  *    to prevent races with other processors.
  165.  *
  166.  *     For uniprocessor debugging, panic when the lock is held (otherwise
  167.  *     we get an infinite loop).
  168.  *
  169.  *    There are three versions of this macro. This is due to the different
  170.  *    sizes of locks. There is only one uniprocessor version. It uses
  171.  *    other macros that are modified by compiler variables. There are
  172.  *    two versions of the multiprocessor implementation. The first is
  173.  *    used when we are keeping hit/miss ratios and the second is for
  174.  *    when we are not.
  175.  *
  176.  * Results:
  177.  *     None.
  178.  *
  179.  * Side effects:
  180.  *    The semaphore has its value set from 0 to 1.
  181.  *    Interrupts are disabled.
  182.  *
  183.  *----------------------------------------------------------------------------
  184.  */
  185.  
  186. #if (MACH_MAX_NUM_PROCESSORS == 1) /* uniprocessor implementation */
  187.  
  188. #define MASTER_LOCK(semaphore) \
  189.     { \
  190.         sync_Instrument[Mach_GetProcessorNumber()].numLocks++; \
  191.     DISABLE_INTR(); \
  192.     if ((semaphore)->value == 1) { \
  193.         SyncDeadlockPanic((semaphore)); \
  194.     } else { \
  195.         (semaphore)->value++;\
  196.         Sync_SemRegister(semaphore); \
  197.         Sync_RecordHit(semaphore); \
  198.         Sync_StoreDbgInfo(semaphore, TRUE); \
  199.         Sync_AddPrior(semaphore); \
  200.     }\
  201.     }
  202.  
  203. #else              /* multiprocessor implementation */
  204.  
  205. #ifdef LOCKREG
  206.  
  207. #define MASTER_LOCK(semaphore) \
  208.     { \
  209.     int missFlag = 0;\
  210.     int pnum = Mach_GetProcessorNumber();\
  211.     int type = ((semaphore)->type > 0) ? (semaphore)->type : 0;\
  212.         sync_InstrumentPtr[pnum]->numLocks++; \
  213.     DISABLE_INTR(); \
  214.     for(;;) { \
  215.         /* \
  216.          * wait until semaphore looks free -- avoid bouncing between \
  217.          * processor caches. \
  218.          */ \
  219.         while((semaphore)->value != 0) { \
  220.         if (missFlag == 0) { \
  221.             missFlag = 1; \
  222.         } \
  223.         sync_InstrumentPtr[pnum]->spinCount[type]++;\
  224.         } \
  225.         if(Mach_TestAndSet(&((semaphore)->value)) == 0) { \
  226.         break; \
  227.         } else if (missFlag == 0) { \
  228.         missFlag = 1; \
  229.         } \
  230.         sync_InstrumentPtr[pnum]->spinCount[type]++;\
  231.     } \
  232.     if(missFlag == 1) { \
  233.         Sync_RecordMiss(semaphore); \
  234.     } \
  235.     Sync_SemRegister(semaphore); \
  236.     Sync_RecordHit(semaphore) ; \
  237.     Sync_StoreDbgInfo(semaphore, TRUE); \
  238.     Sync_AddPrior(semaphore);    \
  239.     }
  240.  
  241. #else   /* LOCKREG -- These are the clean versions of the macros */
  242.  
  243. #define MASTER_LOCK(semaphore) \
  244.     { \
  245.         sync_InstrumentPtr[Mach_GetProcessorNumber()]->numLocks++; \
  246.     DISABLE_INTR(); \
  247.     for(;;) { \
  248.         /* \
  249.          * wait until semaphore looks free -- avoid bouncing between \
  250.          * processor caches. \
  251.          */ \
  252.         while((semaphore)->value != 0) { \
  253.         } \
  254.         if(Mach_TestAndSet(&((semaphore)->value)) == 0) { \
  255.         break; \
  256.         } \
  257.     } \
  258.     }
  259.  
  260. #endif /* LOCKREG */
  261. #endif /*multiprocessor implementation */
  262.  
  263.  
  264. /*
  265.  *----------------------------------------------------------------------------
  266.  *
  267.  * MASTER_UNLOCK --
  268.  *
  269.  *    Leave a critical section guarded by a binary semaphore.  This is for
  270.  *    use in a multiprocessor environment.  Interrupts are enabled and the
  271.  *    semaphore value is reset to 0 to allow other processors entry into
  272.  *    the critical section.
  273.  *
  274.  * Results:
  275.  *     None.
  276.  *
  277.  * Side effects:
  278.  *    The semaphore has its value reset to 0.
  279.  *    Interrupts are enabled.
  280.  *
  281.  *----------------------------------------------------------------------------
  282.  */
  283.  
  284. #define MASTER_UNLOCK(semaphore) \
  285.     { \
  286.     int pnum = Mach_GetProcessorNumber();\
  287.         sync_InstrumentPtr[pnum]->numUnlocks++; \
  288.     (semaphore)->value = 0; \
  289.     SyncDeleteCurrent(semaphore); \
  290.     if (!Mach_AtInterruptLevel()) { \
  291.         --mach_NumDisableIntrsPtr[pnum]; \
  292.         if (mach_NumDisableIntrsPtr[pnum] == 0) { \
  293.         Mach_EnableIntr(); \
  294.         } \
  295.     } \
  296.     }
  297.  
  298.  
  299. /* 
  300.  * Condition variables can be used in critical sections guarded by
  301.  * MASTER_LOCK and MASTER_UNLOCK.  Sync_MasterWait and
  302.  * Sync_MasterBroadcast are the analogues of Sync_Wait and
  303.  * Sync_Broadcast.
  304.  */
  305.  
  306. /*
  307.  *----------------------------------------------------------------------
  308.  *
  309.  * Sync_MasterWait --
  310.  *
  311.  *    Wait on an event with a master lock held.
  312.  *    This has the same semantics as Sync_Wait except
  313.  *    that the lock release when the process sleeps is
  314.  *    a master lock.
  315.  *
  316.  * Results:
  317.  *    None.
  318.  *
  319.  * Side effects:
  320.  *    The process gets descheduled, the master lock gets released
  321.  *    and then reacquired after the condition is notified.
  322.  *
  323.  *----------------------------------------------------------------------
  324.  */
  325.  
  326. #define Sync_MasterWait(conditionPtr, mutexPtr, wakeIfSignal) \
  327.     { \
  328.     (conditionPtr)->waiting = TRUE; \
  329.     (void) Sync_SlowMasterWait((unsigned int) conditionPtr, mutexPtr, \
  330.         wakeIfSignal); \
  331.     }
  332.  
  333. /*
  334.  *----------------------------------------------------------------------
  335.  *
  336.  * Sync_MasterBroadcast --
  337.  *
  338.  *    Notify an event, like Sync_Broadcast except it
  339.  *    should be used with a master lock held because of the
  340.  *    check on conditionPtr->waiting.
  341.  *
  342.  *    (This could verify that a master lock is held.)
  343.  *
  344.  * Results:
  345.  *    None.
  346.  *
  347.  * Side effects:
  348.  *    Notify all processes waiting on the event.
  349.  *
  350.  *----------------------------------------------------------------------
  351.  */
  352.  
  353. #define Sync_MasterBroadcast(conditionPtr) \
  354.     { \
  355.     if ((conditionPtr)->waiting == TRUE) { \
  356.         (void) Sync_SlowBroadcast((unsigned int)conditionPtr, \
  357.                 &(conditionPtr)->waiting); \
  358.     } \
  359.     }
  360.  
  361.  
  362. /*
  363.  *----------------------------------------------------------------------
  364.  *
  365.  * UNLOCK_AND_SWITCH --
  366.  *
  367.  *    Macro to call the internal routine to release the monitor lock and
  368.  *    then context switch.
  369.  *
  370.  * Results:
  371.  *    None.
  372.  *
  373.  * Side effects:
  374.  *    Lock released and process context switched.
  375.  *
  376.  *----------------------------------------------------------------------
  377.  */
  378.  
  379. #define UNLOCK_MONITOR_AND_SWITCH(state) Sync_UnlockAndSwitch(LOCKPTR, state)
  380.  
  381. /*
  382.  *    The initialization routines are used to initialize a semaphore.
  383.  *    The name parameter is the name of the semaphore and is used to
  384.  *    distinguish between types of locks. If you want the statistics
  385.  *    (hit, miss, etc) for two semaphores to be shared then give them the
  386.  *    same name. An example might be locks around file handles, where it
  387.  *    makes more sense to have the statistics for all the locks as a whole,
  388.  *    rather than just one lock. Also beware that no distinction is made
  389.  *    between locks and semaphores when determining types -- if they have
  390.  *    the same name they have the same type.
  391.  *       Sync_SemClear should be called when a semaphore is being deallocated
  392.  *    and will be no longer used. Currently all this routine does is to
  393.  *    take the statistics associated with the semaphore and merge them in
  394.  *    with those for the type as a whole.
  395.  */
  396.  
  397. /*
  398.  *----------------------------------------------------------------------
  399.  *
  400.  * Sync_SemRegister --
  401.  *
  402.  *     Register a semaphore.
  403.  *
  404.  *----------------------------------------------------------------------
  405.  */
  406. #define Sync_SemRegister Sync_LockRegister
  407.  
  408. /* 
  409.  *----------------------------------------------------------------------
  410.  *
  411.  * Sync_SemClear
  412.  * 
  413.  *     Clear a semaphore.
  414.  *
  415.  *----------------------------------------------------------------------
  416.  */
  417. #define Sync_SemClear Sync_LockClear
  418.  
  419.  
  420. /*
  421.  *----------------------------------------------------------------------
  422.  *
  423.  * Sync_SemInitStatic --
  424.  *
  425.  *    Initializes the fields of a semaphore in an initialization statement.
  426.  *    Ex:
  427.  *        static Sync_Semaphore foo = Sync_SemInitStatic("foo");
  428.  *
  429.  * Results:
  430.  *    None.
  431.  *
  432.  * Side effects:
  433.  *    None.
  434.  *
  435.  *----------------------------------------------------------------------
  436.  */
  437.  
  438. #ifdef CLEAN_LOCK
  439.  
  440. #define Sync_SemInitStatic(name) \
  441.     {0}
  442.  
  443. #else
  444. #ifdef LOCKDEP
  445.  
  446. #define Sync_SemInitStatic(name) \
  447.     {0,0,0, SYNC_SEMAPHORE, 0, SYNC_LISTINFO_INIT, name,(Address) NIL, \
  448.      (Proc_ControlBlock *) NIL, 0}
  449.  
  450. #else
  451.  
  452. #ifdef LOCKREG
  453.  
  454. #define Sync_SemInitStatic(name) \
  455.     {0,0,0, SYNC_SEMAPHORE, 0, SYNC_LISTINFO_INIT, name,(Address) NIL, \
  456.      (Proc_ControlBlock *) NIL}
  457. #else
  458. #define Sync_SemInitStatic(name) \
  459.     {0,name, (Address) NIL, (Proc_ControlBlock *) NIL}
  460.  
  461. #endif /* LOCKREG */
  462. #endif /* LOCKDEP */
  463. #endif /* CLEAN_LOCK */
  464.  
  465.  
  466. /*
  467.  *----------------------------------------------------------------------
  468.  *
  469.  * Sync_SemInitDynamic --
  470.  *
  471.  *    Initializes the fields of a semaphore during program execution.
  472.  *    Ex:
  473.  *        Sync_SemInitDynamic(foo,"foo");
  474.  *
  475.  * Results:
  476.  *    None.
  477.  *
  478.  * Side effects:
  479.  *    None.
  480.  *
  481.  *----------------------------------------------------------------------
  482.  */
  483.  
  484. #ifdef CLEAN_LOCK
  485.  
  486. #define Sync_SemInitDynamic(sem,semName) \
  487.     { (sem)->value = 0; }
  488.  
  489. #else
  490. #ifdef LOCKDEP
  491.  
  492. #define Sync_SemInitDynamic(sem, semName) { \
  493.     (sem)->value = (sem)->miss = 0; (sem)->name = semName; \
  494.     (sem)->hit = 0; (sem)->type = 0; \
  495.     (sem)->holderPC = (Address)NIL; (sem)->class = SYNC_SEMAPHORE;\
  496.     (sem)->holderPCBPtr = (Proc_ControlBlock *) NIL; \
  497.     (sem)->priorCount = 0;\
  498.     List_InitElement(&(sem)->listInfo.links);\
  499. }
  500.  
  501.  
  502. #else
  503.  
  504. #ifdef LOCKREG
  505.  
  506. #define Sync_SemInitDynamic(sem, semName) { \
  507.     (sem)->value = (sem)->miss = 0; (sem)->name = semName; \
  508.     (sem)->hit = 0; (sem)->type = 0;\
  509.     (sem)->holderPC = (Address)NIL; (sem)->class = SYNC_SEMAPHORE;\
  510.     (sem)->holderPCBPtr = (Proc_ControlBlock *) NIL; \
  511.     List_InitElement(&(sem)->listInfo.links);\
  512. }
  513.  
  514. #else
  515. #define Sync_SemInitDynamic(sem, semName) { \
  516.     (sem)->value = 0; (sem)->name = semName; \
  517.     (sem)->holderPC = (Address)NIL;\
  518.     (sem)->holderPCBPtr = (Proc_ControlBlock *) NIL; \
  519. }
  520. #endif /* LOCKREG */
  521. #endif /* LOCKDEP */
  522. #endif /* CLEAN_LOCK */
  523.  
  524.  
  525. /*
  526.  *----------------------------------------------------------------------
  527.  *
  528.  * Sync_LockInitStatic --
  529.  *
  530.  *    Initializes the fields of a lock in an initialization statement.
  531.  *    Ex:
  532.  *        static Sync_Lock foo = Sync_LockInitStatic("foo");
  533.  *
  534.  * Results:
  535.  *    None.
  536.  *
  537.  * Side effects:
  538.  *    None.
  539.  *
  540.  *----------------------------------------------------------------------
  541.  */
  542. #ifdef CLEAN_LOCK
  543.  
  544. #define Sync_LockInitStatic(name) {0,0}
  545.  
  546. #else
  547. #ifdef LOCKDEP
  548.  
  549. #define Sync_LockInitStatic(name) \
  550.     {0,0,0,SYNC_LOCK, 0, SYNC_LISTINFO_INIT, 0, name, (Address) NIL, \
  551.      (Proc_ControlBlock *) NIL,0}
  552.  
  553. #else
  554.  
  555. #ifdef LOCKREG
  556.  
  557. #define Sync_LockInitStatic(name) \
  558.     {0,0,0,SYNC_LOCK, 0, SYNC_LISTINFO_INIT, 0, name, (Address) NIL, \
  559.      (Proc_ControlBlock *) NIL}
  560.  
  561. #else
  562. #define Sync_LockInitStatic(name) \
  563.     {0,0,name, (Address) NIL, (Proc_ControlBlock *) NIL}
  564.  
  565.  
  566. #endif /* LOCKREG */
  567. #endif /* LOCKDEP */
  568. #endif /* CLEAN_LOCK */
  569.  
  570.  
  571. /*
  572.  *----------------------------------------------------------------------
  573.  *
  574.  * Sync_LockInitDynamic --
  575.  *
  576.  *    Initializes the fields of a lock during program execution.
  577.  *    Ex:
  578.  *        Sync_LockInitDynamic(foo,"foo");
  579.  *
  580.  * Results:
  581.  *    None.
  582.  *
  583.  * Side effects:
  584.  *    None.
  585.  *
  586.  *----------------------------------------------------------------------
  587.  */
  588.  
  589. #ifdef CLEAN_LOCK
  590.  
  591. #define Sync_LockInitDynamic(lock, lockName) \
  592.     {(lock)->inUse = (lock)->waiting = 0;}
  593.  
  594. #else
  595. #ifdef LOCKDEP
  596.  
  597. #define Sync_LockInitDynamic(lock, lockName) { \
  598.     (lock)->inUse = (lock)->waiting = 0; (lock)->class = SYNC_LOCK;\
  599.     (lock)->hit = (lock)->miss = 0; (lock)->name = lockName; \
  600.     (lock)->holderPC = (Address) NIL; (lock)->type = 0; \
  601.     (lock)->holderPCBPtr  = (Proc_ControlBlock *) NIL; \
  602.     (lock)->priorCount = 0;\
  603.  
  604. #else
  605.  
  606. #ifdef LOCKREG
  607.  
  608. #define Sync_LockInitDynamic(lock, lockName) { \
  609.     (lock)->inUse = (lock)->waiting = 0; (lock)->class = SYNC_LOCK;\
  610.     (lock)->hit = (lock)->miss = 0; (lock)->name = lockName; \
  611.     (lock)->holderPC = (Address) NIL; (lock)->type = 0; \
  612.     (lock)->holderPCBPtr  = (Proc_ControlBlock *) NIL; \
  613. }
  614.  
  615. #else
  616. #define Sync_LockInitDynamic(lock, lockName) { \
  617.     (lock)->inUse = (lock)->waiting = 0;  (lock)->name = lockName; \
  618.     (lock)->holderPC = (Address) NIL; \
  619.     (lock)->holderPCBPtr  = (Proc_ControlBlock *) NIL; \
  620. }
  621.  
  622. #endif /* LOCKREG */
  623. #endif /* LOCKDEP */
  624. #endif /* CLEAN_LOCK */
  625.  
  626.  
  627. /*
  628.  *----------------------------------------------------------------------
  629.  *
  630.  * Sync_IsRegistered --
  631.  *
  632.  *    Returns true if a lock or semaphore has already been registered. If
  633.  *    LOCKREG is not defined then this macro always returns FALSE.
  634.  *
  635.  * Results:
  636.  *    TRUE if lock or semaphore registered.
  637.  *
  638.  * Side effects:
  639.  *    None.
  640.  *
  641.  *----------------------------------------------------------------------
  642.  */
  643.  
  644. #ifdef LOCKREG
  645.  
  646. #define Sync_IsRegistered(lock) \
  647.     (((lock)->type > 0) ? TRUE : FALSE)
  648.  
  649. #else /* LOCKREG */
  650.  
  651. #define Sync_IsRegistered(lock) FALSE
  652.  
  653. #endif /* LOCKREG */
  654.  
  655. /*
  656.  *----------------------------------------------------------------------
  657.  *
  658.  * Sync_LockRegister --
  659.  *
  660.  *    Used to add a lock to the registration database.
  661.  *    If LOCKREG is not defined then this macro does nothing.
  662.  *
  663.  * Results:
  664.  *    None.
  665.  *
  666.  * Side effects:
  667.  *    The lock is registered.
  668.  *
  669.  *----------------------------------------------------------------------
  670.  */
  671. #ifdef LOCKREG
  672.  
  673. #define Sync_LockRegister(lock) \
  674.     { \
  675.     if (!Sync_IsRegistered((Sync_Lock *) lock)) { \
  676.         Sync_RegisterInt((Address) (lock)); \
  677.     } \
  678.     }
  679.  
  680. #else /* LOCKREG */
  681.  
  682. #define Sync_LockRegister(lock) {}
  683.  
  684. #endif /* LOCKREG */
  685.  
  686.  
  687.  
  688. /*
  689.  *----------------------------------------------------------------------
  690.  *
  691.  * Sync_LockClear --
  692.  *
  693.  *    Used to clear and deregister a lock before it is freed.
  694.  *    If LOCKREG is not defined then this macro does nothing.
  695.  *
  696.  * Results:
  697.  *    None.
  698.  *
  699.  * Side effects:
  700.  *    The lock is deregistered.
  701.  *
  702.  *----------------------------------------------------------------------
  703.  */
  704. #ifdef LOCKREG
  705.  
  706. #define Sync_LockClear(lock) \
  707.     { \
  708.     if (Sync_IsRegistered(lock)) { \
  709.         Sync_CheckoutInt((Address) (lock)); \
  710.     } \
  711.     }
  712.  
  713. #else /* LOCKREG */
  714.  
  715. #define Sync_LockClear(sem) 
  716.  
  717. #endif /* LOCKREG */
  718.  
  719. /*
  720.  *----------------------------------------------------------------------
  721.  *
  722.  * Sync_AddPrior --
  723.  *
  724.  *    When a lock is grabbed the prior lock must be added to the prior
  725.  *    types for the lock.
  726.  *    This macro does nothing if LOCKDEP is not defined.
  727.  *
  728.  * Results:
  729.  *    None.
  730.  *
  731.  * Side effects:
  732.  *    None.
  733.  *
  734.  *----------------------------------------------------------------------
  735.  */
  736.  
  737. #ifdef LOCKDEP
  738.  
  739. #define Sync_AddPrior(lockPtr) { \
  740.     Sync_AddPriorInt((lockPtr)->type, &(lockPtr)->priorCount, \
  741.     (lockPtr)->priorTypes, (lockPtr), (lockPtr)->holderPCBPtr);  \
  742. }
  743.  
  744. #else /* LOCKDEP */
  745.  
  746. #define Sync_AddPrior(lockPtr)
  747.  
  748. #endif /* LOCKDEP */
  749.  
  750. /*
  751.  *----------------------------------------------------------------------
  752.  *
  753.  * SyncMergePrior --
  754.  *
  755.  *    When a lock is cleared its statistics must be added to those for
  756.  *    the type as a whole.
  757.  *    This macro does nothing if LOCKDEP is not defined.
  758.  *
  759.  * Results:
  760.  *    None.
  761.  *
  762.  * Side effects:
  763.  *    None.
  764.  *
  765.  *----------------------------------------------------------------------
  766.  */
  767.  
  768. #ifdef LOCKDEP
  769.  
  770. #define SyncMergePrior(lockPtr, regPtr) \
  771.     { SyncMergePriorInt((lockPtr)->priorCount, (lockPtr)->priorTypes, \
  772.                (regPtr)); } 
  773.  
  774. #else /* LOCKDEP */
  775.  
  776. #define SyncMergePrior(lockPtr, regPtr)
  777.  
  778. #endif /* LOCKDEP */
  779.  
  780.  
  781. /*
  782.  *----------------------------------------------------------------------
  783.  *
  784.  * SyncDeleteCurrent --
  785.  *
  786.  *    When we unlock a lock we have to delete it from the stack of 
  787.  *    current locks.
  788.  *    If LOCKDEP is not defined then don't do anything.
  789.  *
  790.  * Results:
  791.  *    None.
  792.  *
  793.  * Side effects:
  794.  *    The lock is removed from the lock stack in the current pcb.
  795.  *
  796.  *----------------------------------------------------------------------
  797.  */
  798.  
  799. #ifdef LOCKDEP
  800.  
  801. #define SyncDeleteCurrent(lockPtr) \
  802.     { SyncDeleteCurrentInt((lockPtr), (lockPtr)->holderPCBPtr); }
  803.  
  804. #else /* LOCKDEP */
  805.  
  806. #define SyncDeleteCurrent(lockPtr) 
  807.  
  808. #endif /* LOCKDEP */
  809.  
  810.  
  811. /*
  812.  *----------------------------------------------------------------------
  813.  *
  814.  * SyncDeadlockPanic --
  815.  *
  816.  *    Prints out a warning message and calls panic. There is one
  817.  *    version for clean locks, and another version for printing
  818.  *    debugging information found in the locks.
  819.  *
  820.  * Results:
  821.  *    None.
  822.  *
  823.  * Side effects:
  824.  *    panic is called.
  825.  *
  826.  *----------------------------------------------------------------------
  827.  */
  828.  
  829. #ifdef CLEAN_LOCK
  830.  
  831. #define SyncDeadlockPanic(semaphore) { \
  832.         panic("Deadlock!!! (semaphore @ 0x%x)\n", (int)(semaphore)); \
  833. }
  834.  
  835. #else /* CLEAN_LOCK */
  836.  
  837. #define SyncDeadlockPanic(semaphore) { \
  838.         panic("Deadlock!!!(%s @ 0x%x)\nHolder PC: 0x%x Current PC: 0x%x\nHolder PCB @ 0x%x Current PCB @ 0x%x\n", \
  839.         (semaphore)->name,(int)(semaphore),(int)(semaphore)->holderPC,\
  840.         (int) Mach_GetPC(),(int) (semaphore)->holderPCBPtr, \
  841.         (int) Proc_GetCurrentProc()); \
  842. }
  843.  
  844. #endif /* CLEAN_LOCK */
  845.  
  846. /*
  847.  *----------------------------------------------------------------------
  848.  *
  849.  * Sync_RecordHit --
  850.  *
  851.  *    If LOCKREG is defined then the hit field of the lock
  852.  *    is incremented.
  853.  *
  854.  * Results:
  855.  *    None.
  856.  *
  857.  * Side effects:
  858.  *    None.
  859.  *
  860.  *----------------------------------------------------------------------
  861.  */
  862.  
  863. #ifndef LOCKREG 
  864.  
  865. #define Sync_RecordHit(lock) {}
  866.  
  867. #else /* LOCKREG */
  868.  
  869. #define Sync_RecordHit(lock) {    (lock)->hit++; }
  870.  
  871. #endif /* LOCKREG */
  872.  
  873. /*
  874.  *----------------------------------------------------------------------
  875.  *
  876.  * Sync_RecordMiss --
  877.  *
  878.  *    If LOCKREG is defined then the miss field of the lock
  879.  *    is incremented.
  880.  *
  881.  * Results:
  882.  *    None.
  883.  *
  884.  * Side effects:
  885.  *    None.
  886.  *
  887.  *----------------------------------------------------------------------
  888.  */
  889. #ifndef LOCKREG
  890.  
  891. #define Sync_RecordMiss(lock) {}
  892.  
  893. #else /* LOCKREG */
  894.  
  895. #define Sync_RecordMiss(lock) { (lock)->miss++; }
  896.  
  897. #endif /* LOCKREG */
  898.  
  899. /*
  900.  *----------------------------------------------------------------------
  901.  *
  902.  * SyncStorDbgInfo --
  903.  *
  904.  *    If CLEAN_LOCK isn't defined then store debugging information
  905.  *    in the lock.  If "lockedByMacro" is TRUE, the lock was obtained
  906.  *    via a macro, so we record the current PC, which is in the
  907.  *    function that invoked the macro.  If it's FALSE, the lock was
  908.  *    obtained by a function whose sole job is to obtain the lock,
  909.  *    so we want to record the PC of that function's caller.
  910.  *
  911.  * Results:
  912.  *    None.
  913.  *
  914.  * Side effects:
  915.  *    None.
  916.  *
  917.  *----------------------------------------------------------------------
  918.  */
  919. #ifdef CLEAN_LOCK
  920.  
  921. #define Sync_StoreDbgInfo(semaphore, lockedByMacro) {}
  922.  
  923. #else /* CLEAN_LOCK */
  924.  
  925. #define Sync_StoreDbgInfo(semaphore, lockedByMacro) {             \
  926.     if ((lockedByMacro) == TRUE) {                    \
  927.     (semaphore)->holderPC = (Address) Mach_GetPC();         \
  928.     } else {                                \
  929.     (semaphore)->holderPC = (Address) Mach_GetCallerPC();         \
  930.     }                                    \
  931.     (semaphore)->holderPCBPtr = Proc_GetCurrentProc();     \
  932. }
  933.  
  934. #endif /* CLEAN_LOCK */
  935. #endif /* _SYNC */
  936.  
  937.